function _extends() {
    _extends = Object.assign ? Object.assign.bind() : function (target) {
        for (var i = 1; i < arguments.length; i++) {
            var source = arguments[i];

            for (var key in source) {
                if (Object.prototype.hasOwnProperty.call(source, key)) {
                    target[key] = source[key];
                }
            }
        }

        return target;
    };
    return _extends.apply(this, arguments);
}

function _inheritsLoose(subClass, superClass) {
    subClass.prototype = Object.create(superClass.prototype);
    subClass.prototype.constructor = subClass;

    _setPrototypeOf(subClass, superClass);
}

function _getPrototypeOf(o) {
    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
        return o.__proto__ || Object.getPrototypeOf(o);
    };
    return _getPrototypeOf(o);
}

function _setPrototypeOf(o, p) {
    _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
        o.__proto__ = p;
        return o;
    };
    return _setPrototypeOf(o, p);
}

function _isNativeReflectConstruct() {
    if (typeof Reflect === 'undefined' || !Reflect.construct) return false;
    if (Reflect.construct.sham) return false;
    if (typeof Proxy === 'function') return true;

    try {
        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
        return true;
    } catch (e) {
        return false;
    }
}

function _construct(Parent, args, Class) {
    if (_isNativeReflectConstruct()) {
        _construct = Reflect.construct.bind();
    } else {
        _construct = function _construct(Parent, args, Class) {
            var a = [null];
            a.push.apply(a, args);
            var Constructor = Function.bind.apply(Parent, a);
            var instance = new Constructor();
            if (Class) _setPrototypeOf(instance, Class.prototype);
            return instance;
        };
    }

    return _construct.apply(null, arguments);
}

function _isNativeFunction(fn) {
    return Function.toString.call(fn).indexOf('[native code]') !== -1;
}

function _wrapNativeSuper(Class) {
    var _cache = typeof Map === 'function' ? new Map() : undefined;

    _wrapNativeSuper = function _wrapNativeSuper(Class) {
        if (Class === null || !_isNativeFunction(Class)) return Class;

        if (typeof Class !== 'function') {
            throw new TypeError('Super expression must either be null or a function');
        }

        if (typeof _cache !== 'undefined') {
            if (_cache.has(Class)) return _cache.get(Class);

            _cache.set(Class, Wrapper);
        }

        function Wrapper() {
            return _construct(Class, arguments, _getPrototypeOf(this).constructor);
        }

        Wrapper.prototype = Object.create(Class.prototype, {
            constructor: {
                value: Wrapper,
                enumerable: false,
                writable: true,
                configurable: true,
            },
        });
        return _setPrototypeOf(Wrapper, Class);
    };

    return _wrapNativeSuper(Class);
}

/* eslint no-console:0 */
var formatRegExp = /%[sdj%]/g;
var warning = function warning() {}; // don't print warning message when in production env or node runtime

if (typeof process !== 'undefined' && process.env && process.env.NODE_ENV !== 'production' && typeof window !== 'undefined' && typeof document !== 'undefined') {
    warning = function warning(type, errors) {
        if (typeof console !== 'undefined' && console.warn && typeof ASYNC_VALIDATOR_NO_WARNING === 'undefined') {
            if (errors.every(function (e) {
                return typeof e === 'string';
            })) {
                console.warn(type, errors);
            }
        }
    };
}

function convertFieldsError(errors) {
    if (!errors || !errors.length) return null;
    var fields = {};
    errors.forEach(function (error) {
        var field = error.field;
        fields[field] = fields[field] || [];
        fields[field].push(error);
    });
    return fields;
}
function format(template) {
    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        args[_key - 1] = arguments[_key];
    }

    var i = 0;
    var len = args.length;

    if (typeof template === 'function') {
        return template.apply(null, args);
    }

    if (typeof template === 'string') {
        var str = template.replace(formatRegExp, function (x) {
            if (x === '%%') {
                return '%';
            }

            if (i >= len) {
                return x;
            }

            switch (x) {
                    case '%s':
                        return String(args[i++]);

                    case '%d':
                        return Number(args[i++]);

                    case '%j':
                        try {
                            return JSON.stringify(args[i++]);
                        } catch (_) {
                            return '[Circular]';
                        }

                        break;

                    default:
                        return x;
            }
        });
        return str;
    }

    return template;
}

function isNativeStringType(type) {
    return type === 'string' || type === 'url' || type === 'hex' || type === 'email' || type === 'date' || type === 'pattern';
}

function isEmptyValue(value, type) {
    if (value === undefined || value === null) {
        return true;
    }

    if (type === 'array' && Array.isArray(value) && !value.length) {
        return true;
    }

    if (isNativeStringType(type) && typeof value === 'string' && !value) {
        return true;
    }

    return false;
}

function asyncParallelArray(arr, func, callback) {
    var results = [];
    var total = 0;
    var arrLength = arr.length;

    function count(errors) {
        results.push.apply(results, errors || []);
        total++;

        if (total === arrLength) {
            callback(results);
        }
    }

    arr.forEach(function (a) {
        func(a, count);
    });
}

function asyncSerialArray(arr, func, callback) {
    var index = 0;
    var arrLength = arr.length;

    function next(errors) {
        if (errors && errors.length) {
            callback(errors);
            return;
        }

        var original = index;
        index = index + 1;

        if (original < arrLength) {
            func(arr[original], next);
        } else {
            callback([]);
        }
    }

    next([]);
}

function flattenObjArr(objArr) {
    var ret = [];
    Object.keys(objArr).forEach(function (k) {
        ret.push.apply(ret, objArr[k] || []);
    });
    return ret;
}

var AsyncValidationError = /*#__PURE__*/function (_Error) {
    _inheritsLoose(AsyncValidationError, _Error);

    function AsyncValidationError(errors, fields) {
        var _this;

        _this = _Error.call(this, 'Async Validation Error') || this;
        _this.errors = errors;
        _this.fields = fields;
        return _this;
    }

    return AsyncValidationError;
}( /*#__PURE__*/_wrapNativeSuper(Error));
function asyncMap(objArr, option, func, callback, source) {
    if (option.first) {
        var _pending = new Promise(function (resolve, reject) {
            var next = function next(errors) {
                callback(errors);
                return errors.length ? reject(new AsyncValidationError(errors, convertFieldsError(errors))) : resolve(source);
            };

            var flattenArr = flattenObjArr(objArr);
            asyncSerialArray(flattenArr, func, next);
        });

        _pending['catch'](function (e) {
            return e;
        });

        return _pending;
    }

    var firstFields = option.firstFields === true ? Object.keys(objArr) : option.firstFields || [];
    var objArrKeys = Object.keys(objArr);
    var objArrLength = objArrKeys.length;
    var total = 0;
    var results = [];
    var pending = new Promise(function (resolve, reject) {
        var next = function next(errors) {
            results.push.apply(results, errors);
            total++;

            if (total === objArrLength) {
                callback(results);
                return results.length ? reject(new AsyncValidationError(results, convertFieldsError(results))) : resolve(source);
            }
        };

        if (!objArrKeys.length) {
            callback(results);
            resolve(source);
        }

        objArrKeys.forEach(function (key) {
            var arr = objArr[key];

            if (firstFields.indexOf(key) !== -1) {
                asyncSerialArray(arr, func, next);
            } else {
                asyncParallelArray(arr, func, next);
            }
        });
    });
    pending['catch'](function (e) {
        return e;
    });
    return pending;
}

function isErrorObj(obj) {
    return !!(obj && obj.message !== undefined);
}

function getValue(value, path) {
    var v = value;

    for (var i = 0; i < path.length; i++) {
        if (v == undefined) {
            return v;
        }

        v = v[path[i]];
    }

    return v;
}

function complementError(rule, source) {
    return function (oe) {
        var fieldValue;

        if (rule.fullFields) {
            fieldValue = getValue(source, rule.fullFields);
        } else {
            fieldValue = source[oe.field || rule.fullField];
        }

        if (isErrorObj(oe)) {
            oe.field = oe.field || rule.fullField;
            oe.fieldValue = fieldValue;
            return oe;
        }

        return {
            message: typeof oe === 'function' ? oe() : oe,
            fieldValue: fieldValue,
            field: oe.field || rule.fullField,
        };
    };
}
function deepMerge(target, source) {
    if (source) {
        for (var s in source) {
            if (source.hasOwnProperty(s)) {
                var value = source[s];

                if (typeof value === 'object' && typeof target[s] === 'object') {
                    target[s] = _extends({}, target[s], value);
                } else {
                    target[s] = value;
                }
            }
        }
    }

    return target;
}

var required$1 = function required(rule, value, source, errors, options, type) {
    if (rule.required && (!source.hasOwnProperty(rule.field) || isEmptyValue(value, type || rule.type))) {
        errors.push(format(options.messages.required, rule.fullField));
    }
};

/**
 *  Rule for validating whitespace.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param source The source object being validated.
 *  @param errors An array of errors that this rule may add
 *  validation errors to.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

var whitespace = function whitespace(rule, value, source, errors, options) {
    if (/^\s+$/.test(value) || value === '') {
        errors.push(format(options.messages.whitespace, rule.fullField));
    }
};

// https://github.com/kevva/url-regex/blob/master/index.js
var urlReg;
var getUrlRegex = (function () {
    if (urlReg) {
        return urlReg;
    }

    var word = '[a-fA-F\\d:]';

    var b = function b(options) {
        return options && options.includeBoundaries ? '(?:(?<=\\s|^)(?=' + word + ')|(?<=' + word + ')(?=\\s|$))' : '';
    };

    var v4 = '(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}';
    var v6seg = '[a-fA-F\\d]{1,4}';
    var v6 = ('\n(?:\n(?:' + v6seg + ':){7}(?:' + v6seg + '|:)|                                    // 1:2:3:4:5:6:7::  1:2:3:4:5:6:7:8\n(?:' + v6seg + ':){6}(?:' + v4 + '|:' + v6seg + '|:)|                             // 1:2:3:4:5:6::    1:2:3:4:5:6::8   1:2:3:4:5:6::8  1:2:3:4:5:6::1.2.3.4\n(?:' + v6seg + ':){5}(?::' + v4 + '|(?::' + v6seg + '){1,2}|:)|                   // 1:2:3:4:5::      1:2:3:4:5::7:8   1:2:3:4:5::8    1:2:3:4:5::7:1.2.3.4\n(?:' + v6seg + ':){4}(?:(?::' + v6seg + '){0,1}:' + v4 + '|(?::' + v6seg + '){1,3}|:)| // 1:2:3:4::        1:2:3:4::6:7:8   1:2:3:4::8      1:2:3:4::6:7:1.2.3.4\n(?:' + v6seg + ':){3}(?:(?::' + v6seg + '){0,2}:' + v4 + '|(?::' + v6seg + '){1,4}|:)| // 1:2:3::          1:2:3::5:6:7:8   1:2:3::8        1:2:3::5:6:7:1.2.3.4\n(?:' + v6seg + ':){2}(?:(?::' + v6seg + '){0,3}:' + v4 + '|(?::' + v6seg + '){1,5}|:)| // 1:2::            1:2::4:5:6:7:8   1:2::8          1:2::4:5:6:7:1.2.3.4\n(?:' + v6seg + ':){1}(?:(?::' + v6seg + '){0,4}:' + v4 + '|(?::' + v6seg + '){1,6}|:)| // 1::              1::3:4:5:6:7:8   1::8            1::3:4:5:6:7:1.2.3.4\n(?::(?:(?::' + v6seg + '){0,5}:' + v4 + '|(?::' + v6seg + '){1,7}|:))             // ::2:3:4:5:6:7:8  ::2:3:4:5:6:7:8  ::8             ::1.2.3.4\n)(?:%[0-9a-zA-Z]{1,})?                                             // %eth0            %1\n').replace(/\s*\/\/.*$/gm, '').replace(/\n/g, '').trim(); // Pre-compile only the exact regexes because adding a global flag make regexes stateful

    var v46Exact = new RegExp('(?:^' + v4 + '$)|(?:^' + v6 + '$)');
    var v4exact = new RegExp('^' + v4 + '$');
    var v6exact = new RegExp('^' + v6 + '$');

    var ip = function ip(options) {
        return options && options.exact ? v46Exact : new RegExp('(?:' + b(options) + v4 + b(options) + ')|(?:' + b(options) + v6 + b(options) + ')', 'g');
    };

    ip.v4 = function (options) {
        return options && options.exact ? v4exact : new RegExp('' + b(options) + v4 + b(options), 'g');
    };

    ip.v6 = function (options) {
        return options && options.exact ? v6exact : new RegExp('' + b(options) + v6 + b(options), 'g');
    };

    var protocol = '(?:(?:[a-z]+:)?//)';
    var auth = '(?:\\S+(?::\\S*)?@)?';
    var ipv4 = ip.v4().source;
    var ipv6 = ip.v6().source;
    var host = '(?:(?:[a-z\\u00a1-\\uffff0-9][-_]*)*[a-z\\u00a1-\\uffff0-9]+)';
    var domain = '(?:\\.(?:[a-z\\u00a1-\\uffff0-9]-*)*[a-z\\u00a1-\\uffff0-9]+)*';
    var tld = '(?:\\.(?:[a-z\\u00a1-\\uffff]{2,}))';
    var port = '(?::\\d{2,5})?';
    var path = '(?:[/?#][^\\s"]*)?';
    var regex = '(?:' + protocol + '|www\\.)' + auth + '(?:localhost|' + ipv4 + '|' + ipv6 + '|' + host + domain + tld + ')' + port + path;
    urlReg = new RegExp('(?:^' + regex + '$)', 'i');
    return urlReg;
});

/* eslint max-len:0 */

var pattern$2 = {
    // http://emailregex.com/
    email: /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+\.)+[a-zA-Z\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]{2,}))$/,
    // url: new RegExp(
    //   '^(?!mailto:)(?:(?:http|https|ftp)://|//)(?:\\S+(?::\\S*)?@)?(?:(?:(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[0-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z\\u00a1-\\uffff0-9]+-*)*[a-z\\u00a1-\\uffff0-9]+)(?:\\.(?:[a-z\\u00a1-\\uffff0-9]+-*)*[a-z\\u00a1-\\uffff0-9]+)*(?:\\.(?:[a-z\\u00a1-\\uffff]{2,})))|localhost)(?::\\d{2,5})?(?:(/|\\?|#)[^\\s]*)?$',
    //   'i',
    // ),
    hex: /^#?([a-f0-9]{6}|[a-f0-9]{3})$/i,
};
var types = {
    integer: function integer(value) {
        return types.number(value) && parseInt(value, 10) === value;
    },
    'float': function float(value) {
        return types.number(value) && !types.integer(value);
    },
    array: function array(value) {
        return Array.isArray(value);
    },
    regexp: function regexp(value) {
        if (value instanceof RegExp) {
            return true;
        }

        try {
            return !!new RegExp(value);
        } catch (e) {
            return false;
        }
    },
    date: function date(value) {
        return typeof value.getTime === 'function' && typeof value.getMonth === 'function' && typeof value.getYear === 'function' && !isNaN(value.getTime());
    },
    number: function number(value) {
        if (isNaN(value)) {
            return false;
        }

        return typeof value === 'number';
    },
    object: function object(value) {
        return typeof value === 'object' && !types.array(value);
    },
    method: function method(value) {
        return typeof value === 'function';
    },
    email: function email(value) {
        return typeof value === 'string' && value.length <= 320 && !!value.match(pattern$2.email);
    },
    url: function url(value) {
        return typeof value === 'string' && value.length <= 2048 && !!value.match(getUrlRegex());
    },
    hex: function hex(value) {
        return typeof value === 'string' && !!value.match(pattern$2.hex);
    },
};

var type$1 = function type(rule, value, source, errors, options) {
    if (rule.required && value === undefined) {
        required$1(rule, value, source, errors, options);
        return;
    }

    var custom = ['integer', 'float', 'array', 'regexp', 'object', 'method', 'email', 'number', 'date', 'url', 'hex'];
    var ruleType = rule.type;

    if (custom.indexOf(ruleType) > -1) {
        if (!types[ruleType](value)) {
            errors.push(format(options.messages.types[ruleType], rule.fullField, rule.type));
        } // straight typeof check

    } else if (ruleType && typeof value !== rule.type) {
        errors.push(format(options.messages.types[ruleType], rule.fullField, rule.type));
    }
};

var range = function range(rule, value, source, errors, options) {
    var len = typeof rule.len === 'number';
    var min = typeof rule.min === 'number';
    var max = typeof rule.max === 'number'; // 正则匹配码点范围从U+010000一直到U+10FFFF的文字（补充平面Supplementary Plane）

    var spRegexp = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
    var val = value;
    var key = null;
    var num = typeof value === 'number';
    var str = typeof value === 'string';
    var arr = Array.isArray(value);

    if (num) {
        key = 'number';
    } else if (str) {
        key = 'string';
    } else if (arr) {
        key = 'array';
    } // if the value is not of a supported type for range validation
    // the validation rule rule should use the
    // type property to also test for a particular type


    if (!key) {
        return false;
    }

    if (arr) {
        val = value.length;
    }

    if (str) {
    // 处理码点大于U+010000的文字length属性不准确的bug，如"𠮷𠮷𠮷".lenght !== 3
        val = value.replace(spRegexp, '_').length;
    }

    if (len) {
        if (val !== rule.len) {
            errors.push(format(options.messages[key].len, rule.fullField, rule.len));
        }
    } else if (min && !max && val < rule.min) {
        errors.push(format(options.messages[key].min, rule.fullField, rule.min));
    } else if (max && !min && val > rule.max) {
        errors.push(format(options.messages[key].max, rule.fullField, rule.max));
    } else if (min && max && (val < rule.min || val > rule.max)) {
        errors.push(format(options.messages[key].range, rule.fullField, rule.min, rule.max));
    }
};

var ENUM$1 = 'enum';

var enumerable$1 = function enumerable(rule, value, source, errors, options) {
    rule[ENUM$1] = Array.isArray(rule[ENUM$1]) ? rule[ENUM$1] : [];

    if (rule[ENUM$1].indexOf(value) === -1) {
        errors.push(format(options.messages[ENUM$1], rule.fullField, rule[ENUM$1].join(', ')));
    }
};

var pattern$1 = function pattern(rule, value, source, errors, options) {
    if (rule.pattern) {
        if (rule.pattern instanceof RegExp) {
            // if a RegExp instance is passed, reset `lastIndex` in case its `global`
            // flag is accidentally set to `true`, which in a validation scenario
            // is not necessary and the result might be misleading
            rule.pattern.lastIndex = 0;

            if (!rule.pattern.test(value)) {
                errors.push(format(options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
            }
        } else if (typeof rule.pattern === 'string') {
            var _pattern = new RegExp(rule.pattern);

            if (!_pattern.test(value)) {
                errors.push(format(options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
            }
        }
    }
};

var rules = {
    required: required$1,
    whitespace: whitespace,
    type: type$1,
    range: range,
    'enum': enumerable$1,
    pattern: pattern$1,
};

var string = function string(rule, value, callback, source, options) {
    var errors = [];
    var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);

    if (validate) {
        if (isEmptyValue(value, 'string') && !rule.required) {
            return callback();
        }

        rules.required(rule, value, source, errors, options, 'string');

        if (!isEmptyValue(value, 'string')) {
            rules.type(rule, value, source, errors, options);
            rules.range(rule, value, source, errors, options);
            rules.pattern(rule, value, source, errors, options);

            if (rule.whitespace === true) {
                rules.whitespace(rule, value, source, errors, options);
            }
        }
    }

    callback(errors);
};

var method = function method(rule, value, callback, source, options) {
    var errors = [];
    var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);

    if (validate) {
        if (isEmptyValue(value) && !rule.required) {
            return callback();
        }

        rules.required(rule, value, source, errors, options);

        if (value !== undefined) {
            rules.type(rule, value, source, errors, options);
        }
    }

    callback(errors);
};

var number = function number(rule, value, callback, source, options) {
    var errors = [];
    var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);

    if (validate) {
        if (value === '') {
            value = undefined;
        }

        if (isEmptyValue(value) && !rule.required) {
            return callback();
        }

        rules.required(rule, value, source, errors, options);

        if (value !== undefined) {
            rules.type(rule, value, source, errors, options);
            rules.range(rule, value, source, errors, options);
        }
    }

    callback(errors);
};

var _boolean = function _boolean(rule, value, callback, source, options) {
    var errors = [];
    var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);

    if (validate) {
        if (isEmptyValue(value) && !rule.required) {
            return callback();
        }

        rules.required(rule, value, source, errors, options);

        if (value !== undefined) {
            rules.type(rule, value, source, errors, options);
        }
    }

    callback(errors);
};

var regexp = function regexp(rule, value, callback, source, options) {
    var errors = [];
    var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);

    if (validate) {
        if (isEmptyValue(value) && !rule.required) {
            return callback();
        }

        rules.required(rule, value, source, errors, options);

        if (!isEmptyValue(value)) {
            rules.type(rule, value, source, errors, options);
        }
    }

    callback(errors);
};

var integer = function integer(rule, value, callback, source, options) {
    var errors = [];
    var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);

    if (validate) {
        if (isEmptyValue(value) && !rule.required) {
            return callback();
        }

        rules.required(rule, value, source, errors, options);

        if (value !== undefined) {
            rules.type(rule, value, source, errors, options);
            rules.range(rule, value, source, errors, options);
        }
    }

    callback(errors);
};

var floatFn = function floatFn(rule, value, callback, source, options) {
    var errors = [];
    var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);

    if (validate) {
        if (isEmptyValue(value) && !rule.required) {
            return callback();
        }

        rules.required(rule, value, source, errors, options);

        if (value !== undefined) {
            rules.type(rule, value, source, errors, options);
            rules.range(rule, value, source, errors, options);
        }
    }

    callback(errors);
};

var array = function array(rule, value, callback, source, options) {
    var errors = [];
    var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);

    if (validate) {
        if ((value === undefined || value === null) && !rule.required) {
            return callback();
        }

        rules.required(rule, value, source, errors, options, 'array');

        if (value !== undefined && value !== null) {
            rules.type(rule, value, source, errors, options);
            rules.range(rule, value, source, errors, options);
        }
    }

    callback(errors);
};

var object = function object(rule, value, callback, source, options) {
    var errors = [];
    var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);

    if (validate) {
        if (isEmptyValue(value) && !rule.required) {
            return callback();
        }

        rules.required(rule, value, source, errors, options);

        if (value !== undefined) {
            rules.type(rule, value, source, errors, options);
        }
    }

    callback(errors);
};

var ENUM = 'enum';

var enumerable = function enumerable(rule, value, callback, source, options) {
    var errors = [];
    var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);

    if (validate) {
        if (isEmptyValue(value) && !rule.required) {
            return callback();
        }

        rules.required(rule, value, source, errors, options);

        if (value !== undefined) {
            rules[ENUM](rule, value, source, errors, options);
        }
    }

    callback(errors);
};

var pattern = function pattern(rule, value, callback, source, options) {
    var errors = [];
    var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);

    if (validate) {
        if (isEmptyValue(value, 'string') && !rule.required) {
            return callback();
        }

        rules.required(rule, value, source, errors, options);

        if (!isEmptyValue(value, 'string')) {
            rules.pattern(rule, value, source, errors, options);
        }
    }

    callback(errors);
};

var date = function date(rule, value, callback, source, options) {
    // console.log('integer rule called %j', rule);
    var errors = [];
    var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field); // console.log('validate on %s value', value);

    if (validate) {
        if (isEmptyValue(value, 'date') && !rule.required) {
            return callback();
        }

        rules.required(rule, value, source, errors, options);

        if (!isEmptyValue(value, 'date')) {
            var dateObject;

            if (value instanceof Date) {
                dateObject = value;
            } else {
                dateObject = new Date(value);
            }

            rules.type(rule, dateObject, source, errors, options);

            if (dateObject) {
                rules.range(rule, dateObject.getTime(), source, errors, options);
            }
        }
    }

    callback(errors);
};

var required = function required(rule, value, callback, source, options) {
    var errors = [];
    var type = Array.isArray(value) ? 'array' : typeof value;
    rules.required(rule, value, source, errors, options, type);
    callback(errors);
};

var type = function type(rule, value, callback, source, options) {
    var ruleType = rule.type;
    var errors = [];
    var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);

    if (validate) {
        if (isEmptyValue(value, ruleType) && !rule.required) {
            return callback();
        }

        rules.required(rule, value, source, errors, options, ruleType);

        if (!isEmptyValue(value, ruleType)) {
            rules.type(rule, value, source, errors, options);
        }
    }

    callback(errors);
};

var any = function any(rule, value, callback, source, options) {
    var errors = [];
    var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);

    if (validate) {
        if (isEmptyValue(value) && !rule.required) {
            return callback();
        }

        rules.required(rule, value, source, errors, options);
    }

    callback(errors);
};

var validators = {
    string: string,
    method: method,
    number: number,
    'boolean': _boolean,
    regexp: regexp,
    integer: integer,
    'float': floatFn,
    array: array,
    object: object,
    'enum': enumerable,
    pattern: pattern,
    date: date,
    url: type,
    hex: type,
    email: type,
    required: required,
    any: any,
};

function newMessages() {
    return {
        'default': 'Validation error on field %s',
        required: '%s is required',
        'enum': '%s must be one of %s',
        whitespace: '%s cannot be empty',
        date: {
            format: '%s date %s is invalid for format %s',
            parse: '%s date could not be parsed, %s is invalid ',
            invalid: '%s date %s is invalid',
        },
        types: {
            string: '%s is not a %s',
            method: '%s is not a %s (function)',
            array: '%s is not an %s',
            object: '%s is not an %s',
            number: '%s is not a %s',
            date: '%s is not a %s',
            'boolean': '%s is not a %s',
            integer: '%s is not an %s',
            'float': '%s is not a %s',
            regexp: '%s is not a valid %s',
            email: '%s is not a valid %s',
            url: '%s is not a valid %s',
            hex: '%s is not a valid %s',
        },
        string: {
            len: '%s must be exactly %s characters',
            min: '%s must be at least %s characters',
            max: '%s cannot be longer than %s characters',
            range: '%s must be between %s and %s characters',
        },
        number: {
            len: '%s must equal %s',
            min: '%s cannot be less than %s',
            max: '%s cannot be greater than %s',
            range: '%s must be between %s and %s',
        },
        array: {
            len: '%s must be exactly %s in length',
            min: '%s cannot be less than %s in length',
            max: '%s cannot be greater than %s in length',
            range: '%s must be between %s and %s in length',
        },
        pattern: {
            mismatch: '%s value %s does not match pattern %s',
        },
        clone: function clone() {
            var cloned = JSON.parse(JSON.stringify(this));
            cloned.clone = this.clone;
            return cloned;
        },
    };
}
var messages = newMessages();

/**
 *  Encapsulates a validation schema.
 *
 *  @param descriptor An object declaring validation rules
 *  for this schema.
 */

var Schema = /*#__PURE__*/function () {
    // ========================= Static =========================
    // ======================== Instance ========================
    function Schema(descriptor) {
        this.rules = null;
        this._messages = messages;
        this.define(descriptor);
    }

    var _proto = Schema.prototype;

    _proto.define = function define(rules) {
        var _this = this;

        if (!rules) {
            throw new Error('Cannot configure a schema with no rules');
        }

        if (typeof rules !== 'object' || Array.isArray(rules)) {
            throw new Error('Rules must be an object');
        }

        this.rules = {};
        Object.keys(rules).forEach(function (name) {
            var item = rules[name];
            _this.rules[name] = Array.isArray(item) ? item : [item];
        });
    };

    _proto.messages = function messages(_messages) {
        if (_messages) {
            this._messages = deepMerge(newMessages(), _messages);
        }

        return this._messages;
    };

    _proto.validate = function validate(source_, o, oc) {
        var _this2 = this;

        if (o === void 0) {
            o = {};
        }

        if (oc === void 0) {
            oc = function oc() {};
        }

        var source = source_;
        var options = o;
        var callback = oc;

        if (typeof options === 'function') {
            callback = options;
            options = {};
        }

        if (!this.rules || Object.keys(this.rules).length === 0) {
            if (callback) {
                callback(null, source);
            }

            return Promise.resolve(source);
        }

        function complete(results) {
            var errors = [];
            var fields = {};

            function add(e) {
                if (Array.isArray(e)) {
                    var _errors;

                    errors = (_errors = errors).concat.apply(_errors, e);
                } else {
                    errors.push(e);
                }
            }

            for (var i = 0; i < results.length; i++) {
                add(results[i]);
            }

            if (!errors.length) {
                callback(null, source);
            } else {
                fields = convertFieldsError(errors);
                callback(errors, fields);
            }
        }

        if (options.messages) {
            var messages$1 = this.messages();

            if (messages$1 === messages) {
                messages$1 = newMessages();
            }

            deepMerge(messages$1, options.messages);
            options.messages = messages$1;
        } else {
            options.messages = this.messages();
        }

        var series = {};
        var keys = options.keys || Object.keys(this.rules);
        keys.forEach(function (z) {
            var arr = _this2.rules[z];
            var value = source[z];
            arr.forEach(function (r) {
                var rule = r;

                if (typeof rule.transform === 'function') {
                    if (source === source_) {
                        source = _extends({}, source);
                    }

                    value = source[z] = rule.transform(value);
                }

                if (typeof rule === 'function') {
                    rule = {
                        validator: rule,
                    };
                } else {
                    rule = _extends({}, rule);
                } // Fill validator. Skip if nothing need to validate


                rule.validator = _this2.getValidationMethod(rule);

                if (!rule.validator) {
                    return;
                }

                rule.field = z;
                rule.fullField = rule.fullField || z;
                rule.type = _this2.getType(rule);
                series[z] = series[z] || [];
                series[z].push({
                    rule: rule,
                    value: value,
                    source: source,
                    field: z,
                });
            });
        });
        var errorFields = {};
        return asyncMap(series, options, function (data, doIt) {
            var rule = data.rule;
            var deep = (rule.type === 'object' || rule.type === 'array') && (typeof rule.fields === 'object' || typeof rule.defaultField === 'object');
            deep = deep && (rule.required || !rule.required && data.value);
            rule.field = data.field;

            function addFullField(key, schema) {
                return _extends({}, schema, {
                    fullField: rule.fullField + '.' + key,
                    fullFields: rule.fullFields ? [].concat(rule.fullFields, [key]) : [key],
                });
            }

            function cb(e) {
                if (e === void 0) {
                    e = [];
                }

                var errorList = Array.isArray(e) ? e : [e];

                if (!options.suppressWarning && errorList.length) {
                    Schema.warning('async-validator:', errorList);
                }

                if (errorList.length && rule.message !== undefined) {
                    errorList = [].concat(rule.message);
                } // Fill error info


                var filledErrors = errorList.map(complementError(rule, source));

                if (options.first && filledErrors.length) {
                    errorFields[rule.field] = 1;
                    return doIt(filledErrors);
                }

                if (!deep) {
                    doIt(filledErrors);
                } else {
                    // if rule is required but the target object
                    // does not exist fail at the rule level and don't
                    // go deeper
                    if (rule.required && !data.value) {
                        if (rule.message !== undefined) {
                            filledErrors = [].concat(rule.message).map(complementError(rule, source));
                        } else if (options.error) {
                            filledErrors = [options.error(rule, format(options.messages.required, rule.field))];
                        }

                        return doIt(filledErrors);
                    }

                    var fieldsSchema = {};

                    if (rule.defaultField) {
                        Object.keys(data.value).map(function (key) {
                            fieldsSchema[key] = rule.defaultField;
                        });
                    }

                    fieldsSchema = _extends({}, fieldsSchema, data.rule.fields);
                    var paredFieldsSchema = {};
                    Object.keys(fieldsSchema).forEach(function (field) {
                        var fieldSchema = fieldsSchema[field];
                        var fieldSchemaList = Array.isArray(fieldSchema) ? fieldSchema : [fieldSchema];
                        paredFieldsSchema[field] = fieldSchemaList.map(addFullField.bind(null, field));
                    });
                    var schema = new Schema(paredFieldsSchema);
                    schema.messages(options.messages);

                    if (data.rule.options) {
                        data.rule.options.messages = options.messages;
                        data.rule.options.error = options.error;
                    }

                    schema.validate(data.value, data.rule.options || options, function (errs) {
                        var finalErrors = [];

                        if (filledErrors && filledErrors.length) {
                            finalErrors.push.apply(finalErrors, filledErrors);
                        }

                        if (errs && errs.length) {
                            finalErrors.push.apply(finalErrors, errs);
                        }

                        doIt(finalErrors.length ? finalErrors : null);
                    });
                }
            }

            var res;

            if (rule.asyncValidator) {
                res = rule.asyncValidator(rule, data.value, cb, data.source, options);
            } else if (rule.validator) {
                try {
                    res = rule.validator(rule, data.value, cb, data.source, options);
                } catch (error) {
                    console.error == null ? void 0 : console.error(error); // rethrow to report error

                    if (!options.suppressValidatorError) {
                        setTimeout(function () {
                            throw error;
                        }, 0);
                    }

                    cb(error.message);
                }

                if (res === true) {
                    cb();
                } else if (res === false) {
                    cb(typeof rule.message === 'function' ? rule.message(rule.fullField || rule.field) : rule.message || (rule.fullField || rule.field) + ' fails');
                } else if (res instanceof Array) {
                    cb(res);
                } else if (res instanceof Error) {
                    cb(res.message);
                }
            }

            if (res && res.then) {
                res.then(function () {
                    return cb();
                }, function (e) {
                    return cb(e);
                });
            }
        }, function (results) {
            complete(results);
        }, source);
    };

    _proto.getType = function getType(rule) {
        if (rule.type === undefined && rule.pattern instanceof RegExp) {
            rule.type = 'pattern';
        }

        if (typeof rule.validator !== 'function' && rule.type && !validators.hasOwnProperty(rule.type)) {
            throw new Error(format('Unknown rule type %s', rule.type));
        }

        return rule.type || 'string';
    };

    _proto.getValidationMethod = function getValidationMethod(rule) {
        if (typeof rule.validator === 'function') {
            return rule.validator;
        }

        var keys = Object.keys(rule);
        var messageIndex = keys.indexOf('message');

        if (messageIndex !== -1) {
            keys.splice(messageIndex, 1);
        }

        if (keys.length === 1 && keys[0] === 'required') {
            return validators.required;
        }

        return validators[this.getType(rule)] || undefined;
    };

    return Schema;
}();

Schema.register = function register(type, validator) {
    if (typeof validator !== 'function') {
        throw new Error('Cannot register a validator by type, validator is not a function');
    }

    validators[type] = validator;
};

Schema.warning = warning;
Schema.messages = messages;
Schema.validators = validators;

export { Schema as default };